/**
 * 工具函数库
 * 提供格式化、验证等通用功能
 */

/**
 * 格式化金额
 * @param {number|string} amount - 金额
 * @param {number} decimals - 小数位数，默认2位
 * @returns {string} 格式化后的金额字符串，如 "¥12.50"
 */
function formatMoney(amount, decimals = CONFIG.MONEY_DECIMAL_PLACES) {
  if (amount === null || amount === undefined || amount === '') {
    return '¥0.00';
  }
  const num = parseFloat(amount);
  if (isNaN(num)) {
    return '¥0.00';
  }
  return '¥' + num.toFixed(decimals);
}

/**
 * 格式化数量
 * @param {number|string} value - 数量值
 * @param {string} unit - 单位
 * @param {number} decimals - 小数位数，默认2位
 * @returns {string} 格式化后的数量字符串，如 "2.5斤"
 */
function formatQuantity(value, unit, decimals = CONFIG.QUANTITY_DECIMAL_PLACES) {
  if (value === null || value === undefined || value === '') {
    return '0' + (unit || '');
  }
  const num = parseFloat(value);
  if (isNaN(num)) {
    return '0' + (unit || '');
  }
  return num.toFixed(decimals) + (unit || '');
}

/**
 * 格式化日期时间
 * @param {string} datetime - ISO日期时间字符串
 * @param {string} format - 格式，默认 'YYYY-MM-DD HH:mm:ss'
 * @returns {string} 格式化后的日期时间字符串
 */
function formatDateTime(datetime, format = CONFIG.DATETIME_FORMAT) {
  if (!datetime) return '';
  const date = new Date(datetime);
  if (isNaN(date.getTime())) return '';
  
  const year = date.getFullYear();
  const month = String(date.getMonth() + 1).padStart(2, '0');
  const day = String(date.getDate()).padStart(2, '0');
  const hours = String(date.getHours()).padStart(2, '0');
  const minutes = String(date.getMinutes()).padStart(2, '0');
  const seconds = String(date.getSeconds()).padStart(2, '0');
  
  if (format === 'YYYY-MM-DD') {
    return `${year}-${month}-${day}`;
  }
  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
}

/**
 * 显示成功提示
 * @param {string} message - 提示信息
 */
function showSuccess(message) {
  // 简单使用alert，后续可以改用更好的提示组件
  alert('✅ ' + message);
}

/**
 * 显示错误提示
 * @param {Error|Object} error - 错误对象
 */
function showError(error) {
  console.error('Error:', error);
  
  let message = '操作失败';
  
  // 处理Axios错误响应
  if (error.response && error.response.data) {
    if (error.response.data.message) {
      message = error.response.data.message;
    } else if (typeof error.response.data === 'string') {
      message = error.response.data;
    }
  } else if (error.message) {
    message = error.message;
  }
  
  alert('❌ ' + message);
}

/**
 * 显示加载中提示
 * @param {string} message - 提示信息
 */
function showLoading(message = '加载中...') {
  // 简单实现，后续可以改用更好的加载组件
  console.log('Loading:', message);
}

/**
 * 隐藏加载中提示
 */
function hideLoading() {
  console.log('Loading complete');
}

/**
 * 验证是否为正数
 * @param {number|string} value - 要验证的值
 * @returns {boolean} 是否为正数
 */
function isPositiveNumber(value) {
  const num = parseFloat(value);
  return !isNaN(num) && num > 0;
}

/**
 * 从URL获取查询参数
 * @param {string} name - 参数名
 * @returns {string|null} 参数值
 */
function getQueryParam(name) {
  const urlParams = new URLSearchParams(window.location.search);
  return urlParams.get(name);
}

/**
 * 设置URL查询参数（不刷新页面）
 * @param {string} name - 参数名
 * @param {string} value - 参数值
 */
function setQueryParam(name, value) {
  const url = new URL(window.location);
  url.searchParams.set(name, value);
  window.history.pushState({}, '', url);
}

/**
 * 本地存储操作封装
 */
const storage = {
  /**
   * 保存数据
   * @param {string} key - 键
   * @param {any} value - 值（会自动JSON序列化）
   */
  set(key, value) {
    try {
      localStorage.setItem(key, JSON.stringify(value));
    } catch (e) {
      console.error('Storage set error:', e);
    }
  },
  
  /**
   * 获取数据
   * @param {string} key - 键
   * @param {any} defaultValue - 默认值
   * @returns {any} 值（会自动JSON反序列化）
   */
  get(key, defaultValue = null) {
    try {
      const value = localStorage.getItem(key);
      return value ? JSON.parse(value) : defaultValue;
    } catch (e) {
      console.error('Storage get error:', e);
      return defaultValue;
    }
  },
  
  /**
   * 删除数据
   * @param {string} key - 键
   */
  remove(key) {
    try {
      localStorage.removeItem(key);
    } catch (e) {
      console.error('Storage remove error:', e);
    }
  },
  
  /**
   * 清空所有数据
   */
  clear() {
    try {
      localStorage.clear();
    } catch (e) {
      console.error('Storage clear error:', e);
    }
  }
};

/**
 * 防抖函数
 * @param {Function} func - 要防抖的函数
 * @param {number} wait - 等待时间（毫秒）
 * @returns {Function} 防抖后的函数
 */
function debounce(func, wait = 300) {
  let timeout;
  return function executedFunction(...args) {
    const later = () => {
      clearTimeout(timeout);
      func(...args);
    };
    clearTimeout(timeout);
    timeout = setTimeout(later, wait);
  };
}

/**
 * 节流函数
 * @param {Function} func - 要节流的函数
 * @param {number} wait - 等待时间（毫秒）
 * @returns {Function} 节流后的函数
 */
function throttle(func, wait = 300) {
  let inThrottle;
  return function executedFunction(...args) {
    if (!inThrottle) {
      func(...args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, wait);
    }
  };
}

/**
 * 获取当前购物车ID（演示模式：通过用户ID获取）
 * @returns {Promise<string>} 购物车ID
 */
async function getCartId() {
  // 优先使用本地存储的购物车ID
  let cartId = storage.get('cartId');
  if (cartId) {
    return cartId;
  }
  
  // 如果本地没有，通过用户ID获取活跃购物车
  try {
    const userId = CONFIG.DEMO_USER_ID;
    const result = await API.getActiveCartByUser(userId);
    
    if (result.data && result.data.id) {
      cartId = result.data.id;
      storage.set('cartId', cartId);
      return cartId;
    }
  } catch (error) {
    console.debug('获取购物车失败，将创建新购物车');
  }
  
  // 如果获取失败，返回null，让调用方创建新购物车
  return null;
}

/**
 * 获取当前用户ID（演示模式）
 * @returns {string} 用户ID
 */
function getUserId() {
  return CONFIG.DEMO_USER_ID;
}

/**
 * 清除购物车ID（用于测试或重置）
 */
function clearCartId() {
  storage.remove('cartId');
}

